home *** CD-ROM | disk | FTP | other *** search
/ Visual Basic Controls / Visual Basic Controls.iso / vbcontrol / ahmmailc / _setup.1 / AHMTMapiMail.hpp < prev    next >
Encoding:
C/C++ Source or Header  |  1998-12-01  |  15.7 KB  |  408 lines
  1. // Borland C++ Builder
  2. // Copyright (c) 1995, 1998 by Borland International
  3. // All rights reserved
  4.  
  5. // (DO NOT EDIT: machine generated header) 'AHMTMapiMail.pas' rev: 3.00
  6.  
  7. #ifndef AHMTMapiMailHPP
  8. #define AHMTMapiMailHPP
  9. #include <SysUtils.hpp>
  10. #include <AHMMails.hpp>
  11. #include <Mapi.hpp>
  12. #include <Classes.hpp>
  13. #include <Windows.hpp>
  14. #include <SysInit.hpp>
  15. #include <System.hpp>
  16.  
  17. //-- user supplied -----------------------------------------------------------
  18.  
  19. namespace Ahmtmapimail
  20. {
  21. //-- type declarations -------------------------------------------------------
  22. class DELPHICLASS TAHMExceptdllerror;
  23. class PASCALIMPLEMENTATION TAHMExceptdllerror : public Sysutils::Exception 
  24. {
  25.     typedef Sysutils::Exception inherited;
  26.     
  27. public:
  28.     /* Exception.Create */ __fastcall TAHMExceptdllerror(const System::AnsiString Msg) : Sysutils::Exception(
  29.         Msg) { }
  30.     /* Exception.CreateFmt */ __fastcall TAHMExceptdllerror(const System::AnsiString Msg, const System::TVarRec 
  31.         * Args, const int Args_Size) : Sysutils::Exception(Msg, Args, Args_Size) { }
  32.     /* Exception.CreateRes */ __fastcall TAHMExceptdllerror(int Ident, Extended Dummy) : Sysutils::Exception(
  33.         Ident, Dummy) { }
  34.     /* Exception.CreateResFmt */ __fastcall TAHMExceptdllerror(int Ident, const System::TVarRec * Args, 
  35.         const int Args_Size) : Sysutils::Exception(Ident, Args, Args_Size) { }
  36.     /* Exception.CreateHelp */ __fastcall TAHMExceptdllerror(const System::AnsiString Msg, int AHelpContext
  37.         ) : Sysutils::Exception(Msg, AHelpContext) { }
  38.     /* Exception.CreateFmtHelp */ __fastcall TAHMExceptdllerror(const System::AnsiString Msg, const System::TVarRec 
  39.         * Args, const int Args_Size, int AHelpContext) : Sysutils::Exception(Msg, Args, Args_Size, AHelpContext
  40.         ) { }
  41.     /* Exception.CreateResHelp */ __fastcall TAHMExceptdllerror(int Ident, int AHelpContext) : Sysutils::
  42.         Exception(Ident, AHelpContext) { }
  43.     /* Exception.CreateResFmtHelp */ __fastcall TAHMExceptdllerror(int Ident, const System::TVarRec * Args
  44.         , const int Args_Size, int AHelpContext) : Sysutils::Exception(Ident, Args, Args_Size, AHelpContext
  45.         ) { }
  46.     
  47. public:
  48.     /* TObject.Destroy */ __fastcall virtual ~TAHMExceptdllerror(void) { }
  49.     
  50. };
  51.  
  52. class DELPHICLASS TAHMExceptAttachmentError;
  53. class PASCALIMPLEMENTATION TAHMExceptAttachmentError : public Sysutils::Exception 
  54. {
  55.     typedef Sysutils::Exception inherited;
  56.     
  57. public:
  58.     /* Exception.Create */ __fastcall TAHMExceptAttachmentError(const System::AnsiString Msg) : Sysutils::
  59.         Exception(Msg) { }
  60.     /* Exception.CreateFmt */ __fastcall TAHMExceptAttachmentError(const System::AnsiString Msg, const 
  61.         System::TVarRec * Args, const int Args_Size) : Sysutils::Exception(Msg, Args, Args_Size) { }
  62.     /* Exception.CreateRes */ __fastcall TAHMExceptAttachmentError(int Ident, Extended Dummy) : Sysutils::
  63.         Exception(Ident, Dummy) { }
  64.     /* Exception.CreateResFmt */ __fastcall TAHMExceptAttachmentError(int Ident, const System::TVarRec 
  65.         * Args, const int Args_Size) : Sysutils::Exception(Ident, Args, Args_Size) { }
  66.     /* Exception.CreateHelp */ __fastcall TAHMExceptAttachmentError(const System::AnsiString Msg, int AHelpContext
  67.         ) : Sysutils::Exception(Msg, AHelpContext) { }
  68.     /* Exception.CreateFmtHelp */ __fastcall TAHMExceptAttachmentError(const System::AnsiString Msg, const 
  69.         System::TVarRec * Args, const int Args_Size, int AHelpContext) : Sysutils::Exception(Msg, Args, Args_Size
  70.         , AHelpContext) { }
  71.     /* Exception.CreateResHelp */ __fastcall TAHMExceptAttachmentError(int Ident, int AHelpContext) : Sysutils::
  72.         Exception(Ident, AHelpContext) { }
  73.     /* Exception.CreateResFmtHelp */ __fastcall TAHMExceptAttachmentError(int Ident, const System::TVarRec 
  74.         * Args, const int Args_Size, int AHelpContext) : Sysutils::Exception(Ident, Args, Args_Size, AHelpContext
  75.         ) { }
  76.     
  77. public:
  78.     /* TObject.Destroy */ __fastcall virtual ~TAHMExceptAttachmentError(void) { }
  79.     
  80. };
  81.  
  82. class DELPHICLASS TAHMExceptunavailable;
  83. class PASCALIMPLEMENTATION TAHMExceptunavailable : public Sysutils::Exception 
  84. {
  85.     typedef Sysutils::Exception inherited;
  86.     
  87. public:
  88.     /* Exception.Create */ __fastcall TAHMExceptunavailable(const System::AnsiString Msg) : Sysutils::Exception(
  89.         Msg) { }
  90.     /* Exception.CreateFmt */ __fastcall TAHMExceptunavailable(const System::AnsiString Msg, const System::TVarRec 
  91.         * Args, const int Args_Size) : Sysutils::Exception(Msg, Args, Args_Size) { }
  92.     /* Exception.CreateRes */ __fastcall TAHMExceptunavailable(int Ident, Extended Dummy) : Sysutils::Exception(
  93.         Ident, Dummy) { }
  94.     /* Exception.CreateResFmt */ __fastcall TAHMExceptunavailable(int Ident, const System::TVarRec * Args
  95.         , const int Args_Size) : Sysutils::Exception(Ident, Args, Args_Size) { }
  96.     /* Exception.CreateHelp */ __fastcall TAHMExceptunavailable(const System::AnsiString Msg, int AHelpContext
  97.         ) : Sysutils::Exception(Msg, AHelpContext) { }
  98.     /* Exception.CreateFmtHelp */ __fastcall TAHMExceptunavailable(const System::AnsiString Msg, const 
  99.         System::TVarRec * Args, const int Args_Size, int AHelpContext) : Sysutils::Exception(Msg, Args, Args_Size
  100.         , AHelpContext) { }
  101.     /* Exception.CreateResHelp */ __fastcall TAHMExceptunavailable(int Ident, int AHelpContext) : Sysutils::
  102.         Exception(Ident, AHelpContext) { }
  103.     /* Exception.CreateResFmtHelp */ __fastcall TAHMExceptunavailable(int Ident, const System::TVarRec 
  104.         * Args, const int Args_Size, int AHelpContext) : Sysutils::Exception(Ident, Args, Args_Size, AHelpContext
  105.         ) { }
  106.     
  107. public:
  108.     /* TObject.Destroy */ __fastcall virtual ~TAHMExceptunavailable(void) { }
  109.     
  110. };
  111.  
  112. typedef int UINT;
  113.  
  114. typedef int ULONG;
  115.  
  116. typedef int *lpULONG;
  117.  
  118. typedef int LHANDLE;
  119.  
  120. typedef int *lpLHANDLE;
  121.  
  122. typedef int DWORD;
  123.  
  124. typedef void *LPVOID;
  125.  
  126. struct TMapiFileDesc;
  127. typedef TMapiFileDesc *lpMapiFileDesc;
  128.  
  129. struct TMapiFileDesc
  130. {
  131.     int ulReserved;
  132.     int flFlags;
  133.     int nPosition;
  134.     char *lpszPathName;
  135.     char *lpszFileName;
  136.     void *lpFileType;
  137. } ;
  138.  
  139. struct TMapiRecipDesc;
  140. typedef TMapiRecipDesc *lpMapiRecipDesc;
  141.  
  142. typedef lpMapiRecipDesc *lppMapiRecipDesc;
  143.  
  144. struct TMapiRecipDesc
  145. {
  146.     int ulReserved;
  147.     int ulRecipClass;
  148.     char *lpszName;
  149.     char *lpszAddress;
  150.     int ulEIDSize;
  151.     void *lpEntryID;
  152. } ;
  153.  
  154. struct TMapiMessage;
  155. typedef TMapiMessage *lpMapiMessage;
  156.  
  157. typedef lpMapiMessage *TlppMapiMessage;
  158.  
  159. struct TMapiMessage
  160. {
  161.     int ulReserved;
  162.     char *lpszSubject;
  163.     char *lpszNoteText;
  164.     char *lpszMessageType;
  165.     char *lpszDateReceived;
  166.     char *lpszConversationID;
  167.     int flFlags;
  168.     TMapiRecipDesc *lpOriginator;
  169.     int nRecipCount;
  170.     TMapiRecipDesc *lpRecips;
  171.     int nFileCount;
  172.     TMapiFileDesc *lpFiles;
  173. } ;
  174.  
  175. class DELPHICLASS TAHMMapiMessage;
  176. typedef void __fastcall (__closure *TAHMOnSendError)(System::TObject* Sender, int ErrorNo, TAHMMapiMessage* 
  177.     Mail);
  178.  
  179. typedef void __fastcall (__closure *TAHMMapiSend)(System::TObject* Sender, TAHMMapiMessage* Mail);
  180.  
  181. typedef void __fastcall (__closure *TAHMMapiConnect)(System::TObject* Sender, int ErrorNo);
  182.  
  183. typedef TMapiRecipDesc TAHMMapiRecipArray[999];
  184.  
  185. class DELPHICLASS TAHMMapiAttachment;
  186. class PASCALIMPLEMENTATION TAHMMapiAttachment : public Classes::TCollectionItem 
  187. {
  188.     typedef Classes::TCollectionItem inherited;
  189.     
  190. private:
  191.     System::AnsiString FFilename;
  192.     TAHMMapiMessage* FAHMMapiMessage;
  193.     virtual System::AnsiString __fastcall GetDisplayName(void);
  194.     
  195. public:
  196.     __fastcall virtual TAHMMapiAttachment(Classes::TCollection* Collection);
  197.     __property TAHMMapiMessage* Owner = {read=FAHMMapiMessage};
  198.     
  199. __published:
  200.     __property System::AnsiString Filename = {read=FFilename, write=FFilename};
  201. public:
  202.     /* TCollectionItem.Destroy */ __fastcall virtual ~TAHMMapiAttachment(void) { }
  203.     
  204. };
  205.  
  206. class DELPHICLASS TAHMMapiAttachments;
  207. class PASCALIMPLEMENTATION TAHMMapiAttachments : public Classes::TCollection 
  208. {
  209.     typedef Classes::TCollection inherited;
  210.     
  211. private:
  212.     TAHMMapiMessage* FAHMMapiMessage;
  213.     TAHMMapiAttachment* __fastcall GeTAHMMapiAttachment(int Index);
  214.     void __fastcall SeTAHMMapiAttachment(int Index, TAHMMapiAttachment* Value);
  215.     
  216. protected:
  217.     DYNAMIC Classes::TPersistent* __fastcall GetOwner(void);
  218.     
  219. public:
  220.     __fastcall TAHMMapiAttachments(TAHMMapiMessage* AOwner);
  221.     HIDESBASE TAHMMapiAttachment* __fastcall Add(System::AnsiString Filename);
  222.     __property TAHMMapiAttachment* Items[int Index] = {read=GeTAHMMapiAttachment, write=SeTAHMMapiAttachment
  223.         /*, default*/};
  224. public:
  225.     /* TCollection.Destroy */ __fastcall virtual ~TAHMMapiAttachments(void) { }
  226.     
  227. };
  228.  
  229. class DELPHICLASS TAHMMapiMail;
  230. class DELPHICLASS TAHMMapiMessages;
  231. class PASCALIMPLEMENTATION TAHMMapiMessages : public Classes::TCollection 
  232. {
  233.     typedef Classes::TCollection inherited;
  234.     
  235. private:
  236.     TAHMMapiMail* FAHMMapiMail;
  237.     TAHMMapiMessage* __fastcall GetAHMMapiMessage(int Index);
  238.     void __fastcall SetAHMMapiMessage(int Index, TAHMMapiMessage* Value);
  239.     
  240. protected:
  241.     DYNAMIC Classes::TPersistent* __fastcall GetOwner(void);
  242.     
  243. public:
  244.     __property TAHMMapiMail* Owner = {read=FAHMMapiMail};
  245.     __fastcall TAHMMapiMessages(TAHMMapiMail* AOwner);
  246.     HIDESBASE TAHMMapiMessage* __fastcall Add(void);
  247.     bool __fastcall Delete(int Index);
  248.     __property TAHMMapiMessage* Items[int Index] = {read=GetAHMMapiMessage, write=SetAHMMapiMessage/*, 
  249.         default*/};
  250. public:
  251.     /* TCollection.Destroy */ __fastcall virtual ~TAHMMapiMessages(void) { }
  252.     
  253. };
  254.  
  255. class PASCALIMPLEMENTATION TAHMMapiMail : public Ahmmails::TAHMMailsComponent 
  256. {
  257.     typedef Ahmmails::TAHMMailsComponent inherited;
  258.     
  259. private:
  260.     TAHMMapiMessages* FAHMMapiMessages;
  261.     int FLogonFlags;
  262.     bool FNewSession;
  263.     System::AnsiString FProfile;
  264.     System::AnsiString FPassword;
  265.     bool FDefaultProfile;
  266.     Classes::TStrings* FSignature;
  267.     Classes::TNotifyEvent FBeforeLogOff;
  268.     Classes::TNotifyEvent FAfterSendAll;
  269.     Classes::TNotifyEvent FBeforeSendAll;
  270.     Classes::TNotifyEvent FBeforeLogon;
  271.     Classes::TNotifyEvent FAfterExecute;
  272.     Classes::TNotifyEvent FOnLogonSuccess;
  273.     Classes::TNotifyEvent FOnLogoffSuccess;
  274.     TAHMOnSendError FOnSendError;
  275.     TAHMMapiSend FOnDeleteMail;
  276.     TAHMMapiSend FBeforeSendMail;
  277.     TAHMMapiSend FAfterSendMail;
  278.     TAHMMapiConnect FOnLogonFailure;
  279.     TAHMMapiConnect FOnLogoffFailure;
  280.     bool FDeleteAfterSend;
  281.     Classes::TNotifyEvent FOnMapiNotAvailable;
  282.     bool __fastcall GetMAPIAvail(void);
  283.     void __fastcall SeTAHMMapiMessages(TAHMMapiMessages* Value);
  284.     TAHMMapiRecipArray __fastcall TheRecipients(TAHMMapiMessage* AHMMessage);
  285.     void __fastcall SetSignature(Classes::TStrings* Value);
  286.     
  287. protected:
  288.     int hSession;
  289.     virtual void __fastcall CheckMAPI(void);
  290.     int __fastcall SendMapi(void);
  291.     int __fastcall Logoff(void);
  292.     int __fastcall Logon(void);
  293.     
  294. public:
  295.     __fastcall virtual TAHMMapiMail(Classes::TComponent* AOwner);
  296.     __fastcall virtual ~TAHMMapiMail(void);
  297.     virtual bool __fastcall Execute(void);
  298.     __property bool MAPIAvail = {read=GetMAPIAvail, nodefault};
  299.     
  300. __published:
  301.     __property bool NewSession = {read=FNewSession, write=FNewSession, default=0};
  302.     __property TAHMMapiMessages* Messages = {read=FAHMMapiMessages, write=SeTAHMMapiMessages};
  303.     __property System::AnsiString Password = {read=FPassword, write=FPassword};
  304.     __property System::AnsiString Profile = {read=FProfile, write=FProfile};
  305.     __property bool DefaultProfile = {read=FDefaultProfile, write=FDefaultProfile, stored=true, default=1
  306.         };
  307.     __property Classes::TStrings* Signature = {read=FSignature, write=SetSignature};
  308.     __property bool DeleteAfterSend = {read=FDeleteAfterSend, write=FDeleteAfterSend, default=1};
  309.     __property Classes::TNotifyEvent BeforeLogon = {read=FBeforeLogon, write=FBeforeLogon};
  310.     __property Classes::TNotifyEvent BeforeSendAll = {read=FBeforeSendAll, write=FBeforeSendAll};
  311.     __property Classes::TNotifyEvent AfterSendAll = {read=FAfterSendAll, write=FAfterSendAll};
  312.     __property Classes::TNotifyEvent BeforeLogoff = {read=FBeforeLogOff, write=FBeforeLogOff};
  313.     __property Classes::TNotifyEvent AfterExecute = {read=FAfterExecute, write=FAfterExecute};
  314.     __property TAHMOnSendError OnSendError = {read=FOnSendError, write=FOnSendError};
  315.     __property Classes::TNotifyEvent OnLogonSuccess = {read=FOnLogonSuccess, write=FOnLogonSuccess};
  316.     __property TAHMMapiConnect OnLogonFailure = {read=FOnLogonFailure, write=FOnLogonFailure};
  317.     __property Classes::TNotifyEvent OnLogoffSuccess = {read=FOnLogoffSuccess, write=FOnLogoffSuccess};
  318.         
  319.     __property Classes::TNotifyEvent OnMapiNotAvailable = {read=FOnMapiNotAvailable, write=FOnMapiNotAvailable
  320.         };
  321.     __property TAHMMapiConnect OnLogoffFailure = {read=FOnLogoffFailure, write=FOnLogoffFailure};
  322.     __property TAHMMapiSend BeforeSendMail = {read=FBeforeSendMail, write=FBeforeSendMail};
  323.     __property TAHMMapiSend AfterSendMail = {read=FAfterSendMail, write=FAfterSendMail};
  324.     __property TAHMMapiSend OnDeleteMail = {read=FOnDeleteMail, write=FOnDeleteMail};
  325. };
  326.  
  327. class PASCALIMPLEMENTATION TAHMMapiMessage : public Classes::TCollectionItem 
  328. {
  329.     typedef Classes::TCollectionItem inherited;
  330.     
  331. private:
  332.     TAHMMapiMail* FAHMMapiMail;
  333.     bool FSendSuccess;
  334.     System::AnsiString FSubject;
  335.     Classes::TStrings* FMessage;
  336.     bool FReceipt;
  337.     bool FDialog;
  338.     Classes::TStrings* FRecipientsTo;
  339.     Classes::TStrings* FRecipientsCC;
  340.     Classes::TStrings* FRecipientsBC;
  341.     TAHMMapiAttachments* FAHMMapiAttachments;
  342.     void __fastcall SeTAHMMapiAttachments(TAHMMapiAttachments* Value);
  343.     void __fastcall SetRecipientsTo(Classes::TStrings* Value);
  344.     void __fastcall SetRecipientsCC(Classes::TStrings* Value);
  345.     void __fastcall SetRecipientsBC(Classes::TStrings* Value);
  346.     void __fastcall SetMessage(Classes::TStrings* Value);
  347.     virtual System::AnsiString __fastcall GetDisplayName(void);
  348.     
  349. public:
  350.     __fastcall virtual TAHMMapiMessage(Classes::TCollection* Collection);
  351.     __fastcall virtual ~TAHMMapiMessage(void);
  352.     __property TAHMMapiMail* Owner = {read=FAHMMapiMail};
  353.     
  354. __published:
  355.     __property Classes::TStrings* Message = {read=FMessage, write=SetMessage};
  356.     __property TAHMMapiAttachments* Attachments = {read=FAHMMapiAttachments, write=SeTAHMMapiAttachments
  357.         };
  358.     __property System::AnsiString Subject = {read=FSubject, write=FSubject};
  359.     __property Classes::TStrings* RecipientsTo = {read=FRecipientsTo, write=SetRecipientsTo};
  360.     __property Classes::TStrings* RecipientsCC = {read=FRecipientsCC, write=SetRecipientsCC};
  361.     __property Classes::TStrings* RecipientsBC = {read=FRecipientsBC, write=SetRecipientsBC};
  362.     __property bool Receipt = {read=FReceipt, write=FReceipt, default=0};
  363.     __property bool Dialog = {read=FDialog, write=FDialog, default=0};
  364. };
  365.  
  366. enum TAHMFaxorMail { ccMail, ccFax };
  367.  
  368. class DELPHICLASS TAHMQuickMail;
  369. class PASCALIMPLEMENTATION TAHMQuickMail : public Ahmmails::TAHMMailsComponent 
  370. {
  371.     typedef Ahmmails::TAHMMailsComponent inherited;
  372.     
  373. private:
  374.     System::AnsiString fname;
  375.     System::AnsiString femail;
  376.     Classes::TNotifyEvent foe;
  377.     Classes::TNotifyEvent fbs;
  378.     TAHMFaxorMail fmf;
  379.     System::AnsiString fsubject;
  380.     System::AnsiString ferr;
  381.     Classes::TStrings* ftext;
  382.     void __fastcall SetText(Classes::TStrings* value);
  383.     
  384. public:
  385.     virtual bool __fastcall Execute(void);
  386.     __fastcall virtual TAHMQuickMail(Classes::TComponent* AOwner);
  387.     __fastcall virtual ~TAHMQuickMail(void);
  388.     
  389. __published:
  390.     __property System::AnsiString ToEmailorFaxAddress = {read=femail, write=femail};
  391.     __property System::AnsiString ToName = {read=fname, write=fname};
  392.     __property Classes::TStrings* TextToSend = {read=ftext, write=SetText};
  393.     __property System::AnsiString Subject = {read=fsubject, write=fsubject};
  394.     __property TAHMFaxorMail MailorFax = {read=fmf, write=fmf, nodefault};
  395.     __property System::AnsiString ErrorNo = {read=ferr, write=ferr};
  396.     __property Classes::TNotifyEvent BeforeSend = {read=fbs, write=fbs};
  397.     __property Classes::TNotifyEvent OnError = {read=foe, write=foe};
  398. };
  399.  
  400. //-- var, const, procedure ---------------------------------------------------
  401.  
  402. }    /* namespace Ahmtmapimail */
  403. #if !defined(NO_IMPLICIT_NAMESPACE_USE)
  404. using namespace Ahmtmapimail;
  405. #endif
  406. //-- end unit ----------------------------------------------------------------
  407. #endif    // AHMTMapiMail
  408.